// test_video_type_apis.js - 视频类型接口测试脚本
const axios = require('axios');
const fs = require('fs');

// API基础URL
const BASE_URL = 'http://localhost:3000/api/video-types';
const AUTH_BASE_URL = 'http://localhost:3000/api/auth';

// 管理员账号信息
const ADMIN_USERNAME = 'admin';
const ADMIN_PASSWORD = '123456';

// 测试结果对象
const testResults = {
  timestamp: new Date().toISOString(),
  tests: [],
  summary: {
    total: 0,
    passed: 0,
    failed: 0
  }
};

// 管理员登录凭证
let adminToken = null;

// 测试视频类型数据
const testTypeData = {
  name: '测试视频类型' + Date.now(),
  description: '这是一个用于测试的视频类型'
};

// 创建的视频类型ID
let createdTypeId = null;

/**
 * 记录测试结果
 */
function recordTestResult(name, passed, error = null) {
  const result = {
    name,
    passed,
    error,
    timestamp: new Date().toISOString()
  };
  
  testResults.tests.push(result);
  testResults.summary.total++;
  
  if (passed) {
    testResults.summary.passed++;
    console.log(`✅ ${name} - 测试通过`);
  } else {
    testResults.summary.failed++;
    console.log(`❌ ${name} - 测试失败: ${error}`);
  }
  
  return passed;
}

/**
 * 保存测试结果到文件
 */
function saveTestResults() {
  const outputPath = './video_type_test_results.json';
  fs.writeFileSync(outputPath, JSON.stringify(testResults, null, 2));
  console.log(`\n测试结果已保存到: ${outputPath}`);
  console.log(`\n测试总结: 总计 ${testResults.summary.total} 个测试, 通过 ${testResults.summary.passed} 个, 失败 ${testResults.summary.failed} 个`);
}

/**
 * 管理员登录
 */
async function loginAdmin() {
  try {
    const response = await axios.post(`${AUTH_BASE_URL}/login`, {
      username: ADMIN_USERNAME,
      password: ADMIN_PASSWORD
    });
    
    if (response.status === 200 && response.data.code === 200) {
      adminToken = response.data.data.token;
      console.log(`\n管理员登录成功，获取到token`);
      return true;
    } else {
      console.log(`管理员登录失败: ${response.data.message || '未知错误'}`);
      return false;
    }
  } catch (error) {
    console.log('管理员登录详细错误:', error);
    console.log(`管理员登录请求失败: ${error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error))}`);
    return false;
  }
}

/**
 * 测试获取所有视频类型（公开接口）
 */
async function testGetAllTypes() {
  try {
    const response = await axios.get(BASE_URL);
    
    if (response.status === 200 && response.data.code === 200 && Array.isArray(response.data.data)) {
      return recordTestResult('获取所有视频类型', true);
    } else {
      return recordTestResult('获取所有视频类型', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('获取所有视频类型详细错误:', error);
      return recordTestResult('获取所有视频类型', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 测试获取视频类型详情（公开接口）
 */
async function testGetTypeById() {
  try {
    // 使用ID为1的视频类型进行测试
    const response = await axios.get(`${BASE_URL}/1`);
    
    if (response.status === 200 && response.data.code === 200 && response.data.data) {
      return recordTestResult('获取视频类型详情', true);
    } else {
      return recordTestResult('获取视频类型详情', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('获取视频类型详情详细错误:', error);
      return recordTestResult('获取视频类型详情', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 测试获取不存在的视频类型
 */
async function testGetNonExistentType() {
  try {
    // 使用一个肯定不存在的ID
    const response = await axios.get(`${BASE_URL}/999999`);
    
    if (response.status === 404 && response.data.code === 404) {
      return recordTestResult('获取不存在的视频类型', true);
    } else {
      return recordTestResult('获取不存在的视频类型', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('获取不存在的视频类型详细错误:', error);
      if (error.response && error.response.status === 404) {
        return recordTestResult('获取不存在的视频类型', true);
      }
      return recordTestResult('获取不存在的视频类型', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 测试创建视频类型（管理员接口）
 */
async function testCreateType() {
  if (!adminToken) {
    return recordTestResult('创建视频类型', false, '未登录管理员');
  }
  
  try {
    const response = await axios.post(BASE_URL, testTypeData, {
      headers: {
        'Authorization': `Bearer ${adminToken}`
      }
    });
    
    if (response.status === 201 && response.data.code === 201 && response.data.data) {
      createdTypeId = response.data.data.type_id;
      return recordTestResult('创建视频类型', true);
    } else {
      return recordTestResult('创建视频类型', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('创建视频类型详细错误:', error);
      return recordTestResult('创建视频类型', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 测试更新视频类型（管理员接口）
 */
async function testUpdateType() {
  if (!adminToken || !createdTypeId) {
    return recordTestResult('更新视频类型', false, '未登录管理员或没有创建的类型ID');
  }
  
  try {
    const updateData = {
      name: '更新后的测试类型',
      description: '更新后的测试描述'
    };
    
    const response = await axios.put(`${BASE_URL}/${createdTypeId}`, updateData, {
      headers: {
        'Authorization': `Bearer ${adminToken}`
      }
    });
    
    if (response.status === 200 && response.data.code === 200 && response.data.data) {
      return recordTestResult('更新视频类型', true);
    } else {
      return recordTestResult('更新视频类型', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('更新视频类型详细错误:', error);
      return recordTestResult('更新视频类型', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 测试删除视频类型（管理员接口）
 */
async function testDeleteType() {
  if (!adminToken || !createdTypeId) {
    return recordTestResult('删除视频类型', false, '未登录管理员或没有创建的类型ID');
  }
  
  try {
    const response = await axios.delete(`${BASE_URL}/${createdTypeId}`, {
      headers: {
        'Authorization': `Bearer ${adminToken}`
      }
    });
    
    if (response.status === 200 && response.data.code === 200) {
      return recordTestResult('删除视频类型', true);
    } else {
      return recordTestResult('删除视频类型', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('删除视频类型详细错误:', error);
      return recordTestResult('删除视频类型', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 测试未授权访问管理员接口
 */
async function testUnauthorizedAccess() {
  try {
    // 尝试不携带token创建类型
    const response = await axios.post(BASE_URL, testTypeData);
    
    if (response.status === 401 && response.data.code === 401) {
      return recordTestResult('未授权访问管理员接口', true);
    } else {
      return recordTestResult('未授权访问管理员接口', false, `状态码: ${response.status}, 响应: ${JSON.stringify(response.data)}`);
    }
  } catch (error) {
      console.log('未授权访问管理员接口详细错误:', error);
      if (error.response && error.response.status === 401) {
        return recordTestResult('未授权访问管理员接口', true);
      }
      return recordTestResult('未授权访问管理员接口', false, error.response?.data?.message || error.message || JSON.stringify(error, Object.getOwnPropertyNames(error)));
    }
}

/**
 * 主测试函数
 */
async function runTests() {
  console.log('开始测试视频类型接口...\n');
  
  try {
    // 测试公开接口
    console.log('===== 测试公开接口 =====');
    await testGetAllTypes();
    await testGetTypeById();
    await testGetNonExistentType();
    
    // 测试未授权访问
    console.log('\n===== 测试未授权访问 =====');
    await testUnauthorizedAccess();
    
    // 尝试管理员登录
    console.log('\n===== 测试管理员接口 =====');
    const loginSuccess = await loginAdmin();
    
    // 如果登录成功，测试管理员接口
    if (loginSuccess) {
      // 测试创建类型
      const createSuccess = await testCreateType();
      
      if (createSuccess && createdTypeId) {
        // 测试修改类型
        await testUpdateType();
        // 测试删除类型
        await testDeleteType();
      }
    }
  } finally {
    // 保存测试结果
    saveTestResults();
  }
}

// 运行测试
runTests().catch(error => {
  console.error('测试过程中发生错误:', error);
  saveTestResults();
});